home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / me39src2.arc / FILEIO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-07-16  |  4.6 KB  |  212 lines
  1. /*
  2.  * The routines in this file read and write ASCII files from the disk. All of
  3.  * the knowledge about files are here.
  4.  */
  5.  
  6. #include        <stdio.h>
  7. #include    "estruct.h"
  8. #include        "edef.h"
  9.  
  10. FILE    *ffp;        /* File pointer, all functions. */
  11. int eofflag;        /* end-of-file flag */
  12.  
  13. /*
  14.  * Open a file for reading.
  15.  */
  16. ffropen(fn)
  17. char    *fn;
  18. {
  19.         if ((ffp=fopen(fn, "r")) == NULL)
  20.                 return (FIOFNF);
  21.     eofflag = FALSE;
  22.         return (FIOSUC);
  23. }
  24.  
  25. /*
  26.  * Open a file for writing. Return TRUE if all is well, and FALSE on error
  27.  * (cannot create).
  28.  */
  29. ffwopen(fn)
  30. char    *fn;
  31. {
  32. #if     VMS
  33.         register int    fd;
  34.  
  35.         if ((fd=creat(fn, 0666, "rfm=var", "rat=cr")) < 0
  36.         || (ffp=fdopen(fd, "w")) == NULL) {
  37. #else
  38.         if ((ffp=fopen(fn, "w")) == NULL) {
  39. #endif
  40.                 mlwrite("Cannot open file for writing");
  41.                 return (FIOERR);
  42.         }
  43.         return (FIOSUC);
  44. }
  45.  
  46. /*
  47.  * Close a file. Should look at the status in all systems.
  48.  */
  49. ffclose()
  50. {
  51.     /* free this since we do not need it anymore */
  52.     if (fline) {
  53.         free(fline);
  54.         fline = NULL;
  55.     }
  56.  
  57. #if    MSDOS & CTRLZ
  58.     fputc(26, ffp);        /* add a ^Z at the end of the file */
  59. #endif
  60.     
  61. #if     V7 | USG | BSD | (MSDOS & (LATTICE | MSC | TURBO))
  62.         if (fclose(ffp) != FALSE) {
  63.                 mlwrite("Error closing file");
  64.                 return(FIOERR);
  65.         }
  66.         return(FIOSUC);
  67. #else
  68.         fclose(ffp);
  69.         return (FIOSUC);
  70. #endif
  71. }
  72.  
  73. /*
  74.  * Write a line to the already opened file. The "buf" points to the buffer,
  75.  * and the "nbuf" is its length, less the free newline. Return the status.
  76.  * Check only at the newline.
  77.  */
  78. ffputline(buf, nbuf)
  79. char    buf[];
  80. {
  81.         register int    i;
  82. #if    CRYPT
  83.     char c;        /* character to translate */
  84.  
  85.     if (cryptflag) {
  86.             for (i = 0; i < nbuf; ++i) {
  87.             c = buf[i] & 0xff;
  88.             crypt(&c, 1);
  89.             fputc(c, ffp);
  90.         }
  91.     } else
  92.             for (i = 0; i < nbuf; ++i)
  93.                     fputc(buf[i]&0xFF, ffp);
  94. #else
  95.         for (i = 0; i < nbuf; ++i)
  96.                 fputc(buf[i]&0xFF, ffp);
  97. #endif
  98.  
  99. #if    ST520
  100.         fputc('\r', ffp);
  101. #endif        
  102.         fputc('\n', ffp);
  103.  
  104.         if (ferror(ffp)) {
  105.                 mlwrite("Write I/O error");
  106.                 return (FIOERR);
  107.         }
  108.  
  109.         return (FIOSUC);
  110. }
  111.  
  112. /*
  113.  * Read a line from a file, and store the bytes in the supplied buffer. The
  114.  * "nbuf" is the length of the buffer. Complain about long lines and lines
  115.  * at the end of the file that don't have a newline present. Check for I/O
  116.  * errors too. Return status.
  117.  */
  118. ffgetline()
  119.  
  120. {
  121.         register int c;        /* current character read */
  122.         register int i;        /* current index into fline */
  123.     register char *tmpline;    /* temp storage for expanding line */
  124.  
  125.     /* if we are at the end...return it */
  126.     if (eofflag)
  127.         return(FIOEOF);
  128.  
  129.     /* dump fline if it ended up too big */
  130.     if (flen > NSTRING) {
  131.         free(fline);
  132.         fline = NULL;
  133.     }
  134.  
  135.     /* if we don't have an fline, allocate one */
  136.     if (fline == NULL)
  137.         if ((fline = malloc(flen = NSTRING)) == NULL)
  138.             return(FIOMEM);
  139.  
  140.     /* read the line in */
  141.         i = 0;
  142.         while ((c = fgetc(ffp)) != EOF && c != '\n') {
  143.                 fline[i++] = c;
  144.         /* if it's longer, get more room */
  145.                 if (i >= flen) {
  146.                     if ((tmpline = malloc(flen+NSTRING)) == NULL)
  147.                         return(FIOMEM);
  148.                     strncpy(tmpline, fline, flen);
  149.                     flen += NSTRING;
  150.                     free(fline);
  151.                     fline = tmpline;
  152.                 }
  153.         }
  154.  
  155. #if    ST520
  156.     if(fline[i-1] == '\r')
  157.         i--;
  158. #endif
  159.  
  160.     /* test for any errors that may have occured */
  161.         if (c == EOF) {
  162.                 if (ferror(ffp)) {
  163.                         mlwrite("File read error");
  164.                         return(FIOERR);
  165.                 }
  166.  
  167.                 if (i != 0)
  168.             eofflag = TRUE;
  169.         else
  170.             return(FIOEOF);
  171.         }
  172.  
  173.     /* terminate and decrypt the string */
  174.         fline[i] = 0;
  175. #if    CRYPT
  176.     if (cryptflag)
  177.         crypt(fline, strlen(fline));
  178. #endif
  179.         return(FIOSUC);
  180. }
  181.  
  182. #if    AZTEC & MSDOS
  183. #undef    fgetc
  184. /*    a1getc:        Get an ascii char from the file input stream
  185.             but DO NOT strip the high bit
  186. */
  187.  
  188. int a1getc(fp)
  189.  
  190. FILE *fp;
  191.  
  192. {
  193.     int c;        /* translated character */
  194.  
  195.     c = getc(fp);    /* get the character */
  196.  
  197.     /* if its a <LF> char, throw it out  */
  198.     while (c == 10)
  199.         c = getc(fp);
  200.  
  201.     /* if its a <RETURN> char, change it to a LF */
  202.     if (c == '\r')
  203.         c = '\n';
  204.  
  205.     /* if its a ^Z, its an EOF */
  206.     if (c == 26)
  207.         c = EOF;
  208.  
  209.     return(c);
  210. }
  211. #endif
  212.